#include "blinking_eyes.h"


// 眼睛状态枚举
typedef enum {
    STATE_IDLE,     // 空闲（左右转动）
    STATE_BLINKING  // 眨眼（上下闭合）
} EyeState;

// 眼睛结构体
typedef struct {
    lv_obj_t *eye;          // 眼睛对象（圆形）
    EyeState state;         // 当前状态（空闲/眨眼）
    int size;               // 眼睛尺寸（直径）
    int pos_x;              // X 坐标（用于转动）
    int pos_y;              // Y 坐标（固定）
    uint32_t next_action;   // 下次动作时间（眨眼/转动）
    int direction;          // 转动方向（-1=左，1=右）
} Eye;

Eye eyes[2];  // 左右眼
lv_obj_t *screen;  // 全局屏幕对象


/**
 * 动画回调：处理眨眼（上下闭合）和转动
 * @param var: Eye 结构体指针
 * @param value: 动画进度（眨眼：0~100；转动：-10~10）
 */
// static void animate_eye(void *var, int32_t value) {
//     Eye *eye = (Eye *)var;
    
//     if (eye->state == STATE_BLINKING) {
//         // 眨眼逻辑：高度从 size → 0 → size
//         int new_h = eye->size - (eye->size * value) / 100;
//         int new_radius = new_h / 2;
//         lv_obj_set_height(eye->eye, new_h);
//         lv_obj_set_style_radius(eye->eye, new_radius, 0);
//     } else if (eye->state == STATE_IDLE) {
//         // 转动逻辑：左右偏移（-10 ~ 10 像素）
//         lv_obj_set_x(eye->eye, eye->pos_x + value);
//     }
// }
static void animate_eye(void *var, int32_t value) {
    Eye *eye = (Eye *)var;

    if (eye->state == STATE_BLINKING) {
        int max_h = eye->size;
        int min_h = 8; // 眨眼最小高度，可根据实际调整
        int new_h;
        if (value <= 100) {
            // 收拢阶段：高度从 max_h 到 min_h
            new_h = max_h - (max_h - min_h) * value / 100;
        } else {
            // 张开阶段：高度从 min_h 到 max_h
            int open_value = value - 100;
            new_h = min_h + (max_h - min_h) * open_value / 100;
        }

        // 以中心为基准调整 y 坐标
        int center_y = eye->pos_y + max_h / 2;
        int new_y = center_y - new_h / 2;

        lv_obj_set_size(eye->eye, eye->size, new_h);
        lv_obj_set_y(eye->eye, new_y);
        lv_obj_set_style_radius(eye->eye, new_h / 2, 0);
    } else if (eye->state == STATE_IDLE) {
        lv_obj_set_x(eye->eye, eye->pos_x + value);
    }
}

/**
 * 启动眨眼动画（上下闭合）
 * @param eye: 眼睛结构体指针
 */
static void start_blink(Eye *eye) {
    eye->state = STATE_BLINKING;
    lv_anim_del(eye, animate_eye);  // 清除旧动画

    // 阶段 1：闭眼（0→100，持续 300ms）
    lv_anim_t close_anim;
    lv_anim_init(&close_anim);
    lv_anim_set_var(&close_anim, eye);
    lv_anim_set_exec_cb(&close_anim, animate_eye);
    lv_anim_set_time(&close_anim, 300);
    lv_anim_set_values(&close_anim, 0, 100);
    lv_anim_start(&close_anim);

    // 阶段 2：睁眼（100→0，持续 300ms，延迟 300ms）
    lv_anim_t open_anim;
    lv_anim_init(&open_anim);
    lv_anim_set_var(&open_anim, eye);
    lv_anim_set_exec_cb(&open_anim, animate_eye);
    lv_anim_set_time(&open_anim, 300);
    lv_anim_set_delay(&open_anim, 300);
    lv_anim_set_values(&open_anim, 100, 0);
    lv_anim_start(&open_anim);

    // 计划下次动作（随机间隔：3~7秒）
    eye->next_action = lv_tick_get() + 1000 + rand() % 1000;
}


/**
 * 启动转动动画（左右看）
 * @param eye: 眼睛结构体指针
 */
static void start_look(Eye *eye) {
    eye->state = STATE_IDLE;
    lv_anim_del(eye, animate_eye);  // 清除旧动画

    // 随机方向（-1=左，1=右）
    eye->direction = (rand() % 2) ? 1 : -1;

    // 转动动画（偏移 -10 ~ 10 像素，持续 500ms）
    lv_anim_t look_anim;
    lv_anim_init(&look_anim);
    lv_anim_set_var(&look_anim, eye);
    lv_anim_set_exec_cb(&look_anim, animate_eye);
    lv_anim_set_time(&look_anim, 500);
    lv_anim_set_values(&look_anim, 0, eye->direction * 20);
    lv_anim_start(&look_anim);

    // 反向转动（回到原位，持续 500ms，延迟 1秒）
    lv_anim_t back_anim;
    lv_anim_init(&back_anim);
    lv_anim_set_var(&back_anim, eye);
    lv_anim_set_exec_cb(&back_anim, animate_eye);
    lv_anim_set_time(&back_anim, 500);
    lv_anim_set_delay(&back_anim, 1000);
    lv_anim_set_values(&back_anim, eye->direction * 10, 0);
    lv_anim_start(&back_anim);

    // 计划下次动作（随机间隔：2~5秒）
    eye->next_action = lv_tick_get() + 1000 + rand() % 1000;
}


/**
 * 定时器回调：处理眨眼/转动逻辑
 */
static void timer_callback(lv_timer_t *timer) {
    uint32_t now = lv_tick_get();
    for (int i = 0; i < 2; i++) {
        Eye *eye = &eyes[i];
        if (now >= eye->next_action) {
            // 随机选择动作：80% 转动，20% 眨眼
            if (rand() % 5 == 0) {
                start_blink(eye);
            } else {
                start_look(eye);
            }
        }
    }
}


/**
 * 创建单个眼睛
 * @param idx: 0=左眼，1=右眼
 * @param size: 眼睛直径（适配 320×240 屏幕）
 */
static void create_eye(int idx, int size) {
    Eye *eye = &eyes[idx];
    eye->size = size;
    eye->state = STATE_IDLE;

    // // 计算初始位置（居中，间距 40 像素）
    // int spacing = 40;
    // eye->pos_x = (240 / 2) - (size + spacing) / 2 + (idx * (size + spacing));
     eye->pos_y = 80;
    

    int center_x = 160; // 屏幕宽度的一半
    int spacing = 120; // 眼睛之间的间距
    if (idx == 0) {
        eye->pos_x = center_x - (spacing / 2) - size / 2; // 左眼在中心左侧
    } else {
        eye->pos_x = center_x + (spacing / 2) - size / 2; // 右眼在中心右侧
    }

    // 创建眼睛对象
    eye->eye = lv_obj_create(screen);
    lv_obj_set_size(eye->eye, size, size);
    lv_obj_set_pos(eye->eye, eye->pos_x, eye->pos_y);
    lv_obj_set_style_radius(eye->eye, size / 2, 0);  // 圆形
    lv_obj_set_style_bg_color(eye->eye, lv_color_hex(0xFFFFFF), 0);  // 白色眼睛
    lv_obj_set_style_border_width(eye->eye, 2, 0);
    lv_obj_set_style_border_color(eye->eye, lv_color_hex(0x000000), 0);  // 黑色边框

    // 初始化动作时间
    eye->next_action = lv_tick_get() + 1000 + rand() % 2000;
}


/**
 * 初始化机器人眼睛（主函数调用）
 */
void init_robot_eyes(void) {
    // 获取屏幕（320×240）
    screen = lv_scr_act();
    if (!screen) return;

    // 设置屏幕背景（黑色）
    lv_obj_set_style_bg_color(screen, lv_color_hex(0x000000), 0);

    // 创建大眼睛（直径 60，适配 320×240）
    create_eye(0, 80);
    create_eye(1, 80);

    // 启动定时器（每 50ms 检查一次）
    lv_timer_create(timer_callback, 50, NULL);
}






void eyesdisplay(void)
{
    // 初始化NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK( ret );
    bsp_i2c_init();  // I2C初始化
    pca9557_init();  // IO扩展芯片初始化
    bsp_lvgl_start(); // 初始化液晶屏lvgl接

    srand(lv_tick_get());  // 初始化随机数
    init_robot_eyes();     // 启动眼睛交互

        while (1) {
        lv_timer_handler();     // 处理 LVGL 定时器
        vTaskDelay(pdMS_TO_TICKS(5)); // 延迟 5ms，降低 CPU 负载
    }
}